import { get, post, put, del } from '../common/utils/request';

// 先修复 getAllPost 函数，添加 return
const loadProducts = async (categoryIndex) => {
  try {
	// 构造请求参数：只有 categoryIndex !== 0 时才传 categoryId
	const url = categoryIndex === 0
	      ? '/api/mall/product/list'
	      : `/api/mall/product/list?categoryId=${categoryIndex}`;
    const response = await get(url);
    if (response.data.code === 200) {
          return response.data.data || []; // 返回商品数组
        } else {
          console.error('API 错误:', response?.message || '未知错误');
          return null;
        } // 返回接口数据
  } catch (error) {
    console.error('请求失败:', error);
    return null; // 错误时返回 null 或默认值
  }
};

	
// 新增：根据 ID 获取商品详情
const getProductDetail = async (id) => {
  try {
    // 使用 get(url, params) 形式传递查询参数
    const response = await get('/api/mall/product/detail', { id });
    if (response.data.code === 200) {
      return response.data.data; // 返回商品对象
    } else {
      console.error('API 错误:', response?.data?.message || '获取商品详情失败');
      return null;
    }
  } catch (error) {
    console.error('请求详情失败:', error);
    return null;
  }
};
const loadProductCategory = async () => {
	try {
		const response = await get(`/api/mall/productCategory/list`);
		return response.data.data;
	} catch (error) {
	  console.error('请求失败:', error);
	  return null; // 错误时返回 null 或默认值
	}
}

// 新增：根据商品 ID 获取用户评价
const getProductReviews = async (id) => {
  try {
    const response = await get('/api/mall/product/review', { id });
    if (response.data.code === 200) {
      return response.data.data || []; // 返回评价列表
    } else {
      console.error('API 错误:', response?.data?.message || '获取评价失败');
      return [];
    }
  } catch (error) {
    console.error('请求评价失败:', error);
    return [];
  }
};

/**
 * 收藏商品
 * @param {number} userId
 * @param {number} productId
 * @returns {Promise<boolean>} 是否成功
 */
const addFavorite = async (userId, productId) => {
  try {
	const url = `/api/mall/favorite/product?productId=${productId}`;
    const response = await post(url);
	
    if (response.data?.code === 200) {
      return true;
    } else {
      console.error('收藏失败:', response?.data?.message || '未知错误');
      return false;
    }
  } catch (error) {
    console.error('请求收藏接口失败:', error);
    return false;
  }
};

/**
 * 取消收藏商品
 * 注意：接口是 DELETE /api/mall/favorite/delete
 * 参数通过 query 传递（@RequestParam）
 */
const removeFavorite = async (userId, productId) => {
  try {
	const url = `/api/mall/favorite/delete?productId=${productId}`;
    const response = await del(url);
    if (response.data?.code === 200) {
      return true;
    } else {
      console.error('取消收藏失败:', response?.data?.message || '未知错误');
      return false;
    }
  } catch (error) {
    console.error('请求取消收藏接口失败:', error);
    return false;
  }
};

/**
 * 查询用户是否收藏了该商品
 * GET /api/mall/favorite/search?userId=1&productId=101
 */
const isFavorite = async (userId, productId) => {
  try {
    const response = await get('/api/mall/favorite/search',
	{productId});
    // 假设返回 { code: 200, data: true/false }
    if (response.data?.code === 200) {
      return Boolean(response.data.data);
    } else {
      console.error('查询收藏状态失败:', response?.data?.message || '未知错误');
      return false;
    }
  } catch (error) {
    console.error('检查收藏状态失败:', error);
    return false;
  }
};

const getFavoriteProductList = async (userId) => {
  try {
    // 使用 get(url, params) 自动拼接 query 参数
    const response = await get('/api/mall/favorite/list');

    if (response.data?.code === 200) {
      return response.data.data || []; // 返回商品列表
    } else {
      console.error('获取收藏列表失败:', response?.data?.message || '未知错误');
      return [];
    }
  } catch (error) {
    console.error('请求收藏列表接口失败:', error);
    return [];
  }
};

/**
 * 获取用户购物车商品列表
 * @param {number|string} userId
 * @returns {Promise<Array|null>} 返回 ShoppingCartDTO 列表，失败返回 []
 */
const getShoppingCartList = async (userId) => {
  try {
    // 使用 get(url, params) 自动拼接 query 参数
    const response = await get('/api/mall/shoppingCart/list', { userId });

    if (response.data?.code === 200) {
      const cartItems = response.data.data || [];
	  console.log('cartItems:',cartItems);
      // 提取并转换为前端需要的格式
      return cartItems.map(item => ({
        id: item.productId,
        cartId: item.cartId,
        name: item.product?.name || '未知商品',
        price: item.product?.price || 0,
        image: item.product?.image || '/static/images/default.png',
        num: item.quantity,
        stock: item.product?.stock || 0,
        selected: item.selected , // 1 表示选中
        productId: item.productId
      }));
	  
    } else {
      console.error('获取购物车失败:', response?.data?.message || '未知错误');
      return [];
    }
  } catch (error) {
    console.error('请求购物车接口失败:', error);
    return [];
  }
};

// 新增：批量更新购物车商品数量
const updateCartQuantity = async (userId, updates) => {
  try {
    // 将前端的 { cartId, num } 转换为后端需要的 { cartId, quantity }
    const items = updates.map(item => ({
      cartId: item.cartId,
      quantity: item.num
    }));

    const requestData = {
      items
    };

    const response = await post('/api/mall/shoppingCart/updateQuantity', requestData);

    if (response.data?.code === 200) {
      return response.data.data; // 成功返回（可能是 null 或 "success" 字符串）
    } else {
      console.error('更新购物车数量失败:', response?.data?.message || '未知错误');
      throw new Error(response?.data?.message || '更新失败');
    }
  } catch (error) {
    console.error('请求更新购物车数量失败:', error);
    throw error; // 抛出错误，让调用者处理
  }
};

// 新增：将收藏商品加入购物车
const addToCartFromFavorite = async (userId, productId) => {
  try {
    // 使用 post(url, data, config) 形式，但这里参数走 query string
    // 所以构造带参数的 URL
    const url = `/api/mall/favorite/addToCart?productId=${productId}`;
    const response = await post(url); // body 为空

    if (response.data?.code === 200) {
      return response.data.data; // 通常是 null 或 success message
    } else {
      console.error('加入购物车失败:', response?.data?.message || '未知错误');
      throw new Error(response?.data?.message || '加入购物车失败');
    }
  } catch (error) {
    console.error('请求加入购物车失败:', error);
    throw error;
  }
};

// 删除购物车中的商品（支持批量）
const deleteCartItems = async (userId, cartIds) => {
  try {
    const response = await del(`/api/mall/shoppingCart/delete/${userId}`, cartIds);
    if (response.data.code === 200) {
      return true; // 成功
    } else {
      console.error('删除失败:', response.data.message || '未知错误');
      return false;
    }
  } catch (error) {
    console.error('删除请求异常:', error);
    return false;
  }
};

/**
 * 创建订单
 * @param {number} userId
 * @param {number} addressId - 用户收货地址 ID
 * @param {number[]} cartIds - 选中的购物车项 ID 数组
 * @returns {Promise<string|null>} 返回订单号（如 "ORD20251107123456"），失败返回 null
 */
const createOrder = async (addressId, cartIds) => {
  try {
    const url = `/api/mall/order/create`;
    const requestData = {
      addressId,
      cartIds
    };
    const response = await post(url, requestData);

    if (response.data?.code === 200) {
      return response.data.data || []; // 返回订单号字符串
    } else {
      console.error('创建订单失败:', response?.data?.message || '未知错误');
      uni.showToast({ title: response?.data?.message || '创建订单失败', icon: 'none' });
      return null;
    }
  } catch (error) {
    console.error('请求创建订单失败:', error);
    uni.showToast({ title: '网络错误，请重试', icon: 'none' });
    return null;
  }
};

/**
 * 根据用户ID获取订单列表
 * @param {number} userId
 * @returns {Promise<Array|null>} 返回订单数组，失败返回 null
 */
const getOrderList = async (userId) => {
  try {
    const response = await get(`/api/mall/order/listByUserId`);
    if (response.data?.code === 200) {
      return response.data.data || [];
    } else {
      console.error('获取订单列表失败:', response?.data?.message || '未知错误');
      uni.showToast({ title: '获取订单失败', icon: 'none' });
      return null;
    }
  } catch (error) {
    console.error('请求订单列表失败:', error);
    uni.showToast({ title: '网络错误，请重试', icon: 'none' });
    return null;
  }
};

// 新增：根据订单 ID 获取订单详情（userId 由后端自动识别）
const getOrderDetail = async (orderId) => {
  try {
    const response = await get(`/api/mall/orderDetail/list?orderId=${orderId}`); // userId 用占位符 0，实际后端忽略
    if (response.data?.code === 200) {
      return response.data.data || []; // 返回订单详情列表
    } else {
      console.error('获取订单详情失败:', response?.data?.message || '未知错误');
      uni.showToast({ title: '获取订单详情失败', icon: 'none' });
      return [];
    }
  } catch (error) {
    console.error('请求订单详情失败:', error);
    uni.showToast({ title: '网络错误，请重试', icon: 'none' });
    return [];
  }
};

const settleOrder = async (orderId) => {
  try {
    const response = await post(`/api/mall/order/settlement?orderId=${orderId}`,);
    if (response.data?.code === 200) {
      return true; // 成功
    } else {
      console.error('结算失败:', response?.data?.message || '未知错误');
      return false;
    }
  } catch (error) {
    console.error('请求结算接口失败:', error);
    return false;
  }
};

const confirmOrder = async (orderId) => {
  try {
    const response = await post(`/api/mall/order/confirm?orderId=${orderId}`,);
    if (response.data?.code === 200) {
      return true; // 成功
    } else {
      console.error('收货失败:', response?.data?.message || '未知错误');
      return false;
    }
  } catch (error) {
    console.error('请求收货接口失败:', error);
    return false;
  }
};

// 提交评价
const addReview = async (orderId, productId, reviewData) => {
  try {
    const url = `/api/mall/review/product?orderId=${orderId}&productId=${encodeURIComponent(productId)}`;
    const response = await post(url, reviewData); // reviewData 必须含 description 和 grade

    if (response.data?.code === 200) {
      return true;
    } else {
      console.error('评价失败:', response?.data?.message || '未知错误');
      uni.showToast({ title: response?.data?.message || '评价失败', icon: 'none' });
      return false;
    }
  } catch (error) {
    console.error('提交评价异常:', error);
    uni.showToast({ title: '网络错误', icon: 'none' });
    return false;
  }
};

/**
 * 根据商品ID创建订单（单商品直购）
 * @param {number} userId
 * @param {number} addressId
 * @param {number} productId
 * @returns {Promise<Array<string>|null>} 返回订单号数组（通常只有一个），失败返回 null
 */
const createOrderByProductId = async (userId, addressId, productId) => {
  try {
    const url = `/api/mall/order/createByProductId`;
    const requestData = {
      addressId,
      productId // 注意：这里传的是 productId，不是 cartIds
    };
    const response = await post(url, requestData);

    if (response.data?.code === 200) {
      return response.data.data || []; // 后端返回 List<String>
    } else {
      console.error('创建直购订单失败:', response?.data?.message || '未知错误');
      uni.showToast({ title: response?.data?.message || '创建订单失败', icon: 'none' });
      return null;
    }
  } catch (error) {
    console.error('请求直购订单接口失败:', error);
    uni.showToast({ title: '网络错误，请重试', icon: 'none' });
    return null;
  }
};

export { 
loadProducts ,
loadProductCategory ,
getProductDetail ,
getProductReviews ,
addFavorite, 
removeFavorite, 
isFavorite,
getFavoriteProductList,
getShoppingCartList,
updateCartQuantity,
addToCartFromFavorite,
deleteCartItems,
createOrder,
getOrderList,
getOrderDetail,
settleOrder,
confirmOrder,
addReview,
createOrderByProductId
 };